/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxWindow7Stride1Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Max, pooling::Forward>;
TYPED_TEST_SUITE(MaxWindow7Stride1Forward, GTestTypePairs);
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28., 29., 30., 31., 32., 32., 32., 32., 36., 37., 38., 39., 40.,
      40., 40., 40., 44., 45., 46., 47., 48., 48., 48., 48., 52., 53.,
      54., 55., 56., 56., 56., 56., 60., 61., 62., 63., 64., 64., 64.,
      64., 60., 61., 62., 63., 64., 64., 64., 64., 60., 61., 62., 63.,
      64., 64., 64., 64., 60., 61., 62., 63., 64., 64., 64., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55., 56., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 119., 120., 121., 122.,
      123., 124., 125., 126., 127., 128., 127., 128., 127., 128., 127., 128.,
      119., 120., 121., 122., 123., 124., 125., 126., 127., 128., 127., 128.,
      127., 128., 127., 128., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {109., 110., 111., 112.,
                                         125., 126., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {217., 218., 219., 220., 221., 222.,
                                         223., 224., 249., 250., 251., 252.,
                                         253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31., 32., 33., 34., 35., 36., 36., 36., 36., 40., 41., 42., 43., 44., 45.,
      45., 45., 45., 49., 50., 51., 52., 53., 54., 54., 54., 54., 58., 59., 60.,
      61., 62., 63., 63., 63., 63., 67., 68., 69., 70., 71., 72., 72., 72., 72.,
      67., 68., 69., 70., 71., 72., 72., 72., 72., 67., 68., 69., 70., 71., 72.,
      72., 72., 72., 67., 68., 69., 70., 71., 72., 72., 72., 72.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61., 62., 63., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 133., 134., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 133., 134., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {121., 122., 123., 124., 125., 126.,
                                         139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 177., 178., 179., 180., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      249., 250., 251., 252., 249., 250., 251., 252., 249., 250., 251., 252.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{1, 8, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34., 35., 36., 37., 38., 39., 40., 40., 40., 40., 44., 45., 46., 47.,
      48., 49., 50., 50., 50., 50., 54., 55., 56., 57., 58., 59., 60., 60.,
      60., 60., 64., 65., 66., 67., 68., 69., 70., 70., 70., 70., 74., 75.,
      76., 77., 78., 79., 80., 80., 80., 80., 74., 75., 76., 77., 78., 79.,
      80., 80., 80., 80., 74., 75., 76., 77., 78., 79., 80., 80., 80., 80.,
      74., 75., 76., 77., 78., 79., 80., 80., 80., 80.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {67., 68., 69., 70.,
                                         77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 147., 148., 149., 150., 151., 152., 153., 154.,
      155., 156., 157., 158., 159., 160., 159., 160., 159., 160., 159., 160.,
      147., 148., 149., 150., 151., 152., 153., 154., 155., 156., 157., 158.,
      159., 160., 159., 160., 159., 160., 159., 160., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {133., 134., 135., 136., 137., 138.,
                                         139., 140., 153., 154., 155., 156.,
                                         157., 158., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      197., 198., 199., 200., 197., 198., 199., 200., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 277., 278., 279., 280.,
      277., 278., 279., 280., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 293., 294., 295., 296.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 309., 310., 311., 312., 313., 314., 315., 316.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275.,
      276., 277., 278., 279., 280., 305., 306., 307., 308., 309., 310.,
      311., 312., 313., 314., 315., 316., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28., 29., 30., 31., 32., 32., 32., 32., 36., 37., 38., 39., 40., 40., 40.,
      40., 44., 45., 46., 47., 48., 48., 48., 48., 52., 53., 54., 55., 56., 56.,
      56., 56., 60., 61., 62., 63., 64., 64., 64., 64., 68., 69., 70., 71., 72.,
      72., 72., 72., 68., 69., 70., 71., 72., 72., 72., 72., 68., 69., 70., 71.,
      72., 72., 72., 72., 68., 69., 70., 71., 72., 72., 72., 72.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55., 56., 63., 64., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      143., 144., 143., 144., 135., 136., 137., 138., 139., 140., 141., 142.,
      143., 144., 143., 144., 143., 144., 143., 144., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {109., 110., 111., 112., 125., 126.,
                                         127., 128., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 269., 270., 271., 272.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      285., 286., 287., 288., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217., 218., 219., 220., 221., 222., 223., 224., 249., 250., 251., 252.,
      253., 254., 255., 256., 281., 282., 283., 284., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{1, 9, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31., 32., 33., 34., 35., 36., 36., 36., 36., 40., 41., 42., 43., 44.,
      45., 45., 45., 45., 49., 50., 51., 52., 53., 54., 54., 54., 54., 58.,
      59., 60., 61., 62., 63., 63., 63., 63., 67., 68., 69., 70., 71., 72.,
      72., 72., 72., 76., 77., 78., 79., 80., 81., 81., 81., 81., 76., 77.,
      78., 79., 80., 81., 81., 81., 81., 76., 77., 78., 79., 80., 81., 81.,
      81., 81., 76., 77., 78., 79., 80., 81., 81., 81., 81.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61., 62., 63., 70., 71.,
                                         72., 79., 80., 81.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 161., 162.,
      161., 162., 161., 162., 161., 162., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 161., 162.,
      161., 162., 161., 162., 161., 162.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {121., 122., 123., 124., 125., 126.,
                                         139., 140., 141., 142., 143., 144.,
                                         157., 158., 159., 160., 161., 162.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 177., 178., 179., 180., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      249., 250., 251., 252., 249., 250., 251., 252., 249., 250., 251., 252.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.};
  const std::array<int, 4> in_shape = {{1, 9, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34., 35., 36., 37., 38., 39., 40., 40., 40., 40., 44., 45., 46.,
      47., 48., 49., 50., 50., 50., 50., 54., 55., 56., 57., 58., 59.,
      60., 60., 60., 60., 64., 65., 66., 67., 68., 69., 70., 70., 70.,
      70., 74., 75., 76., 77., 78., 79., 80., 80., 80., 80., 84., 85.,
      86., 87., 88., 89., 90., 90., 90., 90., 84., 85., 86., 87., 88.,
      89., 90., 90., 90., 90., 84., 85., 86., 87., 88., 89., 90., 90.,
      90., 90., 84., 85., 86., 87., 88., 89., 90., 90., 90., 90.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {67., 68., 69., 70., 77., 78.,
                                         79., 80., 87., 88., 89., 90.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      167., 168., 169., 170., 171., 172., 173., 174., 175., 176., 177., 178.,
      179., 180., 179., 180., 179., 180., 179., 180., 167., 168., 169., 170.,
      171., 172., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.,
      179., 180., 179., 180., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 153., 154., 155., 156.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      197., 198., 199., 200., 197., 198., 199., 200., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 277., 278., 279., 280.,
      277., 278., 279., 280., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      333., 334., 335., 336., 337., 338., 339., 340., 341., 342., 343., 344.,
      345., 346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      357., 358., 359., 360., 333., 334., 335., 336., 337., 338., 339., 340.,
      341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{1, 9, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28., 29., 30., 31., 32., 32., 32., 32., 36., 37., 38., 39., 40., 40.,
      40., 40., 44., 45., 46., 47., 48., 48., 48., 48., 52., 53., 54., 55.,
      56., 56., 56., 56., 60., 61., 62., 63., 64., 64., 64., 64., 68., 69.,
      70., 71., 72., 72., 72., 72., 76., 77., 78., 79., 80., 80., 80., 80.,
      76., 77., 78., 79., 80., 80., 80., 80., 76., 77., 78., 79., 80., 80.,
      80., 80., 76., 77., 78., 79., 80., 80., 80., 80.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55., 56., 63., 64.,
                                         71., 72., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 151., 152., 153., 154., 155., 156., 157., 158.,
      159., 160., 159., 160., 159., 160., 159., 160., 151., 152., 153., 154.,
      155., 156., 157., 158., 159., 160., 159., 160., 159., 160., 159., 160.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {109., 110., 111., 112., 125., 126.,
                                         127., 128., 141., 142., 143., 144.,
                                         157., 158., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 301., 302., 303., 304.,
      305., 306., 307., 308., 309., 310., 311., 312., 313., 314., 315., 316.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217., 218., 219., 220., 221., 222., 223., 224., 249., 250., 251.,
      252., 253., 254., 255., 256., 281., 282., 283., 284., 285., 286.,
      287., 288., 313., 314., 315., 316., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31., 32., 33., 34., 35., 36., 36., 36., 36., 40., 41., 42., 43.,
      44., 45., 45., 45., 45., 49., 50., 51., 52., 53., 54., 54., 54.,
      54., 58., 59., 60., 61., 62., 63., 63., 63., 63., 67., 68., 69.,
      70., 71., 72., 72., 72., 72., 76., 77., 78., 79., 80., 81., 81.,
      81., 81., 85., 86., 87., 88., 89., 90., 90., 90., 90., 85., 86.,
      87., 88., 89., 90., 90., 90., 90., 85., 86., 87., 88., 89., 90.,
      90., 90., 90., 85., 86., 87., 88., 89., 90., 90., 90., 90.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61., 62., 63., 70., 71., 72.,
                                         79., 80., 81., 88., 89., 90.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 179., 180., 179., 180., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 179., 180., 179., 180., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 139., 140., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 175., 176., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 177., 178., 179., 180., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      249., 250., 251., 252., 249., 250., 251., 252., 249., 250., 251., 252.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{1, 10, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,  40.,  44., 45.,
      46.,  47.,  48.,  49.,  50.,  50.,  50.,  50.,  54.,  55.,  56., 57.,
      58.,  59.,  60.,  60.,  60.,  60.,  64.,  65.,  66.,  67.,  68., 69.,
      70.,  70.,  70.,  70.,  74.,  75.,  76.,  77.,  78.,  79.,  80., 80.,
      80.,  80.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  90.,  90., 90.,
      94.,  95.,  96.,  97.,  98.,  99.,  100., 100., 100., 100., 94., 95.,
      96.,  97.,  98.,  99.,  100., 100., 100., 100., 94.,  95.,  96., 97.,
      98.,  99.,  100., 100., 100., 100., 94.,  95.,  96.,  97.,  98., 99.,
      100., 100., 100., 100.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {67., 68., 69., 70., 77., 78.,
                                         79., 80., 87., 88., 89., 90.,
                                         97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197., 198.,
      199., 200., 199., 200., 199., 200., 199., 200., 187., 188., 189., 190.,
      191., 192., 193., 194., 195., 196., 197., 198., 199., 200., 199., 200.,
      199., 200., 199., 200., 187., 188., 189., 190., 191., 192., 193., 194.,
      195., 196., 197., 198., 199., 200., 199., 200., 199., 200., 199., 200.,
      187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197., 198.,
      199., 200., 199., 200., 199., 200., 199., 200.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 153., 154., 155.,
      156., 157., 158., 159., 160., 173., 174., 175., 176., 177., 178.,
      179., 180., 193., 194., 195., 196., 197., 198., 199., 200.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      197., 198., 199., 200., 197., 198., 199., 200., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 277., 278., 279., 280.,
      277., 278., 279., 280., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 343., 344., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 357., 358., 359., 360., 357., 358., 359., 360.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395., 396.,
      397., 398., 399., 400., 397., 398., 399., 400., 397., 398., 399., 400.,
      397., 398., 399., 400., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 385., 386., 387., 388., 389., 390., 391., 392.,
      393., 394., 395., 396., 397., 398., 399., 400., 397., 398., 399., 400.,
      397., 398., 399., 400., 397., 398., 399., 400., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 385., 386., 387., 388.,
      389., 390., 391., 392., 393., 394., 395., 396., 397., 398., 399., 400.,
      397., 398., 399., 400., 397., 398., 399., 400., 397., 398., 399., 400.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395., 396.,
      397., 398., 399., 400., 397., 398., 399., 400., 397., 398., 399., 400.,
      397., 398., 399., 400.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275.,
      276., 277., 278., 279., 280., 305., 306., 307., 308., 309., 310.,
      311., 312., 313., 314., 315., 316., 317., 318., 319., 320., 345.,
      346., 347., 348., 349., 350., 351., 352., 353., 354., 355., 356.,
      357., 358., 359., 360., 385., 386., 387., 388., 389., 390., 391.,
      392., 393., 394., 395., 396., 397., 398., 399., 400.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  30.,  31.,  32.,  32.,  32.,  32.,  36.,  37.,  38.,  39.,
      40.,  40.,  40.,  40.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  48.,
      52.,  53.,  54.,  55.,  56.,  56.,  56.,  56.,  60.,  61.,  62.,  63.,
      64.,  64.,  64.,  64.,  60.,  61.,  62.,  63.,  64.,  64.,  64.,  64.,
      60.,  61.,  62.,  63.,  64.,  64.,  64.,  64.,  60.,  61.,  62.,  63.,
      64.,  64.,  64.,  64.,  92.,  93.,  94.,  95.,  96.,  96.,  96.,  96.,
      100., 101., 102., 103., 104., 104., 104., 104., 108., 109., 110., 111.,
      112., 112., 112., 112., 116., 117., 118., 119., 120., 120., 120., 120.,
      124., 125., 126., 127., 128., 128., 128., 128., 124., 125., 126., 127.,
      128., 128., 128., 128., 124., 125., 126., 127., 128., 128., 128., 128.,
      124., 125., 126., 127., 128., 128., 128., 128., 156., 157., 158., 159.,
      160., 160., 160., 160., 164., 165., 166., 167., 168., 168., 168., 168.,
      172., 173., 174., 175., 176., 176., 176., 176., 180., 181., 182., 183.,
      184., 184., 184., 184., 188., 189., 190., 191., 192., 192., 192., 192.,
      188., 189., 190., 191., 192., 192., 192., 192., 188., 189., 190., 191.,
      192., 192., 192., 192., 188., 189., 190., 191., 192., 192., 192., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55.,  56.,  63.,  64.,  119., 120.,
                                         127., 128., 183., 184., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 119., 120., 121., 122.,
      123., 124., 125., 126., 127., 128., 127., 128., 127., 128., 127., 128.,
      119., 120., 121., 122., 123., 124., 125., 126., 127., 128., 127., 128.,
      127., 128., 127., 128., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 183., 184., 185., 186.,
      187., 188., 189., 190., 191., 192., 191., 192., 191., 192., 191., 192.,
      199., 200., 201., 202., 203., 204., 205., 206., 207., 208., 207., 208.,
      207., 208., 207., 208., 215., 216., 217., 218., 219., 220., 221., 222.,
      223., 224., 223., 224., 223., 224., 223., 224., 231., 232., 233., 234.,
      235., 236., 237., 238., 239., 240., 239., 240., 239., 240., 239., 240.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 255., 256.,
      255., 256., 255., 256., 247., 248., 249., 250., 251., 252., 253., 254.,
      255., 256., 255., 256., 255., 256., 255., 256., 247., 248., 249., 250.,
      251., 252., 253., 254., 255., 256., 255., 256., 255., 256., 255., 256.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 255., 256.,
      255., 256., 255., 256., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 327., 328., 329., 330.,
      331., 332., 333., 334., 335., 336., 335., 336., 335., 336., 335., 336.,
      343., 344., 345., 346., 347., 348., 349., 350., 351., 352., 351., 352.,
      351., 352., 351., 352., 359., 360., 361., 362., 363., 364., 365., 366.,
      367., 368., 367., 368., 367., 368., 367., 368., 375., 376., 377., 378.,
      379., 380., 381., 382., 383., 384., 383., 384., 383., 384., 383., 384.,
      375., 376., 377., 378., 379., 380., 381., 382., 383., 384., 383., 384.,
      383., 384., 383., 384., 375., 376., 377., 378., 379., 380., 381., 382.,
      383., 384., 383., 384., 383., 384., 383., 384., 375., 376., 377., 378.,
      379., 380., 381., 382., 383., 384., 383., 384., 383., 384., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 125., 126., 127., 128., 237., 238., 239., 240.,
      253., 254., 255., 256., 365., 366., 367., 368., 381., 382., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 237., 238., 239., 240., 241., 242., 243., 244.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      237., 238., 239., 240., 241., 242., 243., 244., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 253., 254., 255., 256., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 365., 366., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 377., 378., 379., 380., 381., 382., 383., 384.,
      381., 382., 383., 384., 381., 382., 383., 384., 381., 382., 383., 384.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 413., 414., 415., 416.,
      413., 414., 415., 416., 413., 414., 415., 416., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      445., 446., 447., 448., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 493., 494., 495., 496.,
      497., 498., 499., 500., 501., 502., 503., 504., 505., 506., 507., 508.,
      509., 510., 511., 512., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 493., 494., 495., 496., 497., 498., 499., 500.,
      501., 502., 503., 504., 505., 506., 507., 508., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 509., 510., 511., 512.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 653., 654., 655., 656., 657., 658., 659., 660.,
      661., 662., 663., 664., 665., 666., 667., 668., 669., 670., 671., 672.,
      669., 670., 671., 672., 669., 670., 671., 672., 669., 670., 671., 672.,
      685., 686., 687., 688., 689., 690., 691., 692., 693., 694., 695., 696.,
      697., 698., 699., 700., 701., 702., 703., 704., 701., 702., 703., 704.,
      701., 702., 703., 704., 701., 702., 703., 704., 717., 718., 719., 720.,
      721., 722., 723., 724., 725., 726., 727., 728., 729., 730., 731., 732.,
      733., 734., 735., 736., 733., 734., 735., 736., 733., 734., 735., 736.,
      733., 734., 735., 736., 749., 750., 751., 752., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.,
      749., 750., 751., 752., 753., 754., 755., 756., 757., 758., 759., 760.,
      761., 762., 763., 764., 765., 766., 767., 768., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 749., 750., 751., 752.,
      753., 754., 755., 756., 757., 758., 759., 760., 761., 762., 763., 764.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.,
      765., 766., 767., 768., 749., 750., 751., 752., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217., 218., 219., 220., 221., 222., 223., 224., 249., 250., 251., 252.,
      253., 254., 255., 256., 473., 474., 475., 476., 477., 478., 479., 480.,
      505., 506., 507., 508., 509., 510., 511., 512., 729., 730., 731., 732.,
      733., 734., 735., 736., 761., 762., 763., 764., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  33.,  34.,  35.,  36.,  36.,  36.,  36.,  40.,  41.,  42.,
      43.,  44.,  45.,  45.,  45.,  45.,  49.,  50.,  51.,  52.,  53.,  54.,
      54.,  54.,  54.,  58.,  59.,  60.,  61.,  62.,  63.,  63.,  63.,  63.,
      67.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,  67.,  68.,  69.,
      70.,  71.,  72.,  72.,  72.,  72.,  67.,  68.,  69.,  70.,  71.,  72.,
      72.,  72.,  72.,  67.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,
      103., 104., 105., 106., 107., 108., 108., 108., 108., 112., 113., 114.,
      115., 116., 117., 117., 117., 117., 121., 122., 123., 124., 125., 126.,
      126., 126., 126., 130., 131., 132., 133., 134., 135., 135., 135., 135.,
      139., 140., 141., 142., 143., 144., 144., 144., 144., 139., 140., 141.,
      142., 143., 144., 144., 144., 144., 139., 140., 141., 142., 143., 144.,
      144., 144., 144., 139., 140., 141., 142., 143., 144., 144., 144., 144.,
      175., 176., 177., 178., 179., 180., 180., 180., 180., 184., 185., 186.,
      187., 188., 189., 189., 189., 189., 193., 194., 195., 196., 197., 198.,
      198., 198., 198., 202., 203., 204., 205., 206., 207., 207., 207., 207.,
      211., 212., 213., 214., 215., 216., 216., 216., 216., 211., 212., 213.,
      214., 215., 216., 216., 216., 216., 211., 212., 213., 214., 215., 216.,
      216., 216., 216., 211., 212., 213., 214., 215., 216., 216., 216., 216.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61.,  62.,  63.,  70.,  71.,  72.,
                                         133., 134., 135., 142., 143., 144.,
                                         205., 206., 207., 214., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 133., 134., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 133., 134., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      215., 216., 215., 216., 215., 216., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 233., 234., 233., 234., 233., 234.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      251., 252., 251., 252., 251., 252., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 269., 270., 269., 270., 269., 270.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 287., 288., 277., 278., 279., 280., 281., 282.,
      283., 284., 285., 286., 287., 288., 287., 288., 287., 288., 287., 288.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 287., 288., 277., 278., 279., 280., 281., 282.,
      283., 284., 285., 286., 287., 288., 287., 288., 287., 288., 287., 288.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      359., 360., 359., 360., 359., 360., 367., 368., 369., 370., 371., 372.,
      373., 374., 375., 376., 377., 378., 377., 378., 377., 378., 377., 378.,
      385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395., 396.,
      395., 396., 395., 396., 395., 396., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 413., 414., 413., 414., 413., 414.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.,
      431., 432., 431., 432., 431., 432., 421., 422., 423., 424., 425., 426.,
      427., 428., 429., 430., 431., 432., 431., 432., 431., 432., 431., 432.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.,
      431., 432., 431., 432., 431., 432., 421., 422., 423., 424., 425., 426.,
      427., 428., 429., 430., 431., 432., 431., 432., 431., 432., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 139., 140., 141., 142., 143., 144.,
      265., 266., 267., 268., 269., 270., 283., 284., 285., 286., 287., 288.,
      409., 410., 411., 412., 413., 414., 427., 428., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 177., 178., 179., 180., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      249., 250., 251., 252., 249., 250., 251., 252., 249., 250., 251., 252.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      409., 410., 411., 412., 413., 414., 415., 416., 417., 418., 419., 420.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.,
      429., 430., 431., 432., 429., 430., 431., 432., 429., 430., 431., 432.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      465., 466., 467., 468., 465., 466., 467., 468., 465., 466., 467., 468.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.,
      517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      537., 538., 539., 540., 537., 538., 539., 540., 537., 538., 539., 540.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      697., 698., 699., 700., 701., 702., 703., 704., 705., 706., 707., 708.,
      709., 710., 711., 712., 713., 714., 715., 716., 717., 718., 719., 720.,
      717., 718., 719., 720., 717., 718., 719., 720., 717., 718., 719., 720.,
      733., 734., 735., 736., 737., 738., 739., 740., 741., 742., 743., 744.,
      745., 746., 747., 748., 749., 750., 751., 752., 753., 754., 755., 756.,
      753., 754., 755., 756., 753., 754., 755., 756., 753., 754., 755., 756.,
      769., 770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,
      781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791., 792.,
      789., 790., 791., 792., 789., 790., 791., 792., 789., 790., 791., 792.,
      805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      825., 826., 827., 828., 825., 826., 827., 828., 825., 826., 827., 828.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.};
  const std::array<int, 4> in_shape = {{3, 8, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,  40.,  44.,  45.,
      46.,  47.,  48.,  49.,  50.,  50.,  50.,  50.,  54.,  55.,  56.,  57.,
      58.,  59.,  60.,  60.,  60.,  60.,  64.,  65.,  66.,  67.,  68.,  69.,
      70.,  70.,  70.,  70.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,
      80.,  80.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,
      74.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,  74.,  75.,
      76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,  114., 115., 116., 117.,
      118., 119., 120., 120., 120., 120., 124., 125., 126., 127., 128., 129.,
      130., 130., 130., 130., 134., 135., 136., 137., 138., 139., 140., 140.,
      140., 140., 144., 145., 146., 147., 148., 149., 150., 150., 150., 150.,
      154., 155., 156., 157., 158., 159., 160., 160., 160., 160., 154., 155.,
      156., 157., 158., 159., 160., 160., 160., 160., 154., 155., 156., 157.,
      158., 159., 160., 160., 160., 160., 154., 155., 156., 157., 158., 159.,
      160., 160., 160., 160., 194., 195., 196., 197., 198., 199., 200., 200.,
      200., 200., 204., 205., 206., 207., 208., 209., 210., 210., 210., 210.,
      214., 215., 216., 217., 218., 219., 220., 220., 220., 220., 224., 225.,
      226., 227., 228., 229., 230., 230., 230., 230., 234., 235., 236., 237.,
      238., 239., 240., 240., 240., 240., 234., 235., 236., 237., 238., 239.,
      240., 240., 240., 240., 234., 235., 236., 237., 238., 239., 240., 240.,
      240., 240., 234., 235., 236., 237., 238., 239., 240., 240., 240., 240.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  77.,  78.,  79.,  80.,  147., 148., 149., 150.,
      157., 158., 159., 160., 227., 228., 229., 230., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 147., 148., 149., 150., 151., 152., 153., 154.,
      155., 156., 157., 158., 159., 160., 159., 160., 159., 160., 159., 160.,
      147., 148., 149., 150., 151., 152., 153., 154., 155., 156., 157., 158.,
      159., 160., 159., 160., 159., 160., 159., 160., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 227., 228., 229., 230., 231., 232., 233., 234.,
      235., 236., 237., 238., 239., 240., 239., 240., 239., 240., 239., 240.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 257., 258.,
      259., 260., 259., 260., 259., 260., 259., 260., 267., 268., 269., 270.,
      271., 272., 273., 274., 275., 276., 277., 278., 279., 280., 279., 280.,
      279., 280., 279., 280., 287., 288., 289., 290., 291., 292., 293., 294.,
      295., 296., 297., 298., 299., 300., 299., 300., 299., 300., 299., 300.,
      307., 308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 307., 308., 309., 310.,
      311., 312., 313., 314., 315., 316., 317., 318., 319., 320., 319., 320.,
      319., 320., 319., 320., 307., 308., 309., 310., 311., 312., 313., 314.,
      315., 316., 317., 318., 319., 320., 319., 320., 319., 320., 319., 320.,
      307., 308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 387., 388., 389., 390.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 399., 400.,
      399., 400., 399., 400., 407., 408., 409., 410., 411., 412., 413., 414.,
      415., 416., 417., 418., 419., 420., 419., 420., 419., 420., 419., 420.,
      427., 428., 429., 430., 431., 432., 433., 434., 435., 436., 437., 438.,
      439., 440., 439., 440., 439., 440., 439., 440., 447., 448., 449., 450.,
      451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 459., 460.,
      459., 460., 459., 460., 467., 468., 469., 470., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.,
      467., 468., 469., 470., 471., 472., 473., 474., 475., 476., 477., 478.,
      479., 480., 479., 480., 479., 480., 479., 480., 467., 468., 469., 470.,
      471., 472., 473., 474., 475., 476., 477., 478., 479., 480., 479., 480.,
      479., 480., 479., 480., 467., 468., 469., 470., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 153., 154., 155., 156.,
      157., 158., 159., 160., 293., 294., 295., 296., 297., 298., 299., 300.,
      313., 314., 315., 316., 317., 318., 319., 320., 453., 454., 455., 456.,
      457., 458., 459., 460., 473., 474., 475., 476., 477., 478., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      197., 198., 199., 200., 197., 198., 199., 200., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 237., 238., 239., 240., 237., 238., 239., 240.,
      253., 254., 255., 256., 257., 258., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 277., 278., 279., 280.,
      277., 278., 279., 280., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 293., 294., 295., 296.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 309., 310., 311., 312., 313., 314., 315., 316.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 293., 294., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 453., 454., 455., 456.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 513., 514., 515., 516.,
      517., 518., 519., 520., 517., 518., 519., 520., 517., 518., 519., 520.,
      517., 518., 519., 520., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 545., 546., 547., 548., 549., 550., 551., 552.,
      553., 554., 555., 556., 557., 558., 559., 560., 557., 558., 559., 560.,
      557., 558., 559., 560., 557., 558., 559., 560., 573., 574., 575., 576.,
      577., 578., 579., 580., 581., 582., 583., 584., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      597., 598., 599., 600., 597., 598., 599., 600., 597., 598., 599., 600.,
      613., 614., 615., 616., 617., 618., 619., 620., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 613., 614., 615., 616., 617., 618., 619., 620.,
      621., 622., 623., 624., 625., 626., 627., 628., 629., 630., 631., 632.,
      633., 634., 635., 636., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 637., 638., 639., 640., 613., 614., 615., 616.,
      617., 618., 619., 620., 621., 622., 623., 624., 625., 626., 627., 628.,
      629., 630., 631., 632., 633., 634., 635., 636., 637., 638., 639., 640.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      613., 614., 615., 616., 617., 618., 619., 620., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 773., 774., 775., 776., 777., 778., 779., 780.,
      781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791., 792.,
      793., 794., 795., 796., 797., 798., 799., 800., 797., 798., 799., 800.,
      797., 798., 799., 800., 797., 798., 799., 800., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      829., 830., 831., 832., 833., 834., 835., 836., 837., 838., 839., 840.,
      837., 838., 839., 840., 837., 838., 839., 840., 837., 838., 839., 840.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      865., 866., 867., 868., 869., 870., 871., 872., 873., 874., 875., 876.,
      877., 878., 879., 880., 877., 878., 879., 880., 877., 878., 879., 880.,
      877., 878., 879., 880., 893., 894., 895., 896., 897., 898., 899., 900.,
      901., 902., 903., 904., 905., 906., 907., 908., 909., 910., 911., 912.,
      913., 914., 915., 916., 917., 918., 919., 920., 917., 918., 919., 920.,
      917., 918., 919., 920., 917., 918., 919., 920., 933., 934., 935., 936.,
      937., 938., 939., 940., 941., 942., 943., 944., 945., 946., 947., 948.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.,
      933., 934., 935., 936., 937., 938., 939., 940., 941., 942., 943., 944.,
      945., 946., 947., 948., 949., 950., 951., 952., 953., 954., 955., 956.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.,
      957., 958., 959., 960., 933., 934., 935., 936., 937., 938., 939., 940.,
      941., 942., 943., 944., 945., 946., 947., 948., 949., 950., 951., 952.,
      953., 954., 955., 956., 957., 958., 959., 960., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 933., 934., 935., 936.,
      937., 938., 939., 940., 941., 942., 943., 944., 945., 946., 947., 948.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 585., 586., 587., 588.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 905., 906., 907., 908., 909., 910., 911., 912.,
      913., 914., 915., 916., 917., 918., 919., 920., 945., 946., 947., 948.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  30.,  31.,  32.,  32.,  32.,  32.,  36.,  37.,  38.,  39.,
      40.,  40.,  40.,  40.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  48.,
      52.,  53.,  54.,  55.,  56.,  56.,  56.,  56.,  60.,  61.,  62.,  63.,
      64.,  64.,  64.,  64.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,
      68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,  68.,  69.,  70.,  71.,
      72.,  72.,  72.,  72.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,
      100., 101., 102., 103., 104., 104., 104., 104., 108., 109., 110., 111.,
      112., 112., 112., 112., 116., 117., 118., 119., 120., 120., 120., 120.,
      124., 125., 126., 127., 128., 128., 128., 128., 132., 133., 134., 135.,
      136., 136., 136., 136., 140., 141., 142., 143., 144., 144., 144., 144.,
      140., 141., 142., 143., 144., 144., 144., 144., 140., 141., 142., 143.,
      144., 144., 144., 144., 140., 141., 142., 143., 144., 144., 144., 144.,
      172., 173., 174., 175., 176., 176., 176., 176., 180., 181., 182., 183.,
      184., 184., 184., 184., 188., 189., 190., 191., 192., 192., 192., 192.,
      196., 197., 198., 199., 200., 200., 200., 200., 204., 205., 206., 207.,
      208., 208., 208., 208., 212., 213., 214., 215., 216., 216., 216., 216.,
      212., 213., 214., 215., 216., 216., 216., 216., 212., 213., 214., 215.,
      216., 216., 216., 216., 212., 213., 214., 215., 216., 216., 216., 216.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {55.,  56.,  63.,  64.,  71.,  72.,
                                         127., 128., 135., 136., 143., 144.,
                                         199., 200., 207., 208., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      143., 144., 143., 144., 135., 136., 137., 138., 139., 140., 141., 142.,
      143., 144., 143., 144., 143., 144., 143., 144., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      199., 200., 201., 202., 203., 204., 205., 206., 207., 208., 207., 208.,
      207., 208., 207., 208., 215., 216., 217., 218., 219., 220., 221., 222.,
      223., 224., 223., 224., 223., 224., 223., 224., 231., 232., 233., 234.,
      235., 236., 237., 238., 239., 240., 239., 240., 239., 240., 239., 240.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 255., 256.,
      255., 256., 255., 256., 263., 264., 265., 266., 267., 268., 269., 270.,
      271., 272., 271., 272., 271., 272., 271., 272., 279., 280., 281., 282.,
      283., 284., 285., 286., 287., 288., 287., 288., 287., 288., 287., 288.,
      279., 280., 281., 282., 283., 284., 285., 286., 287., 288., 287., 288.,
      287., 288., 287., 288., 279., 280., 281., 282., 283., 284., 285., 286.,
      287., 288., 287., 288., 287., 288., 287., 288., 279., 280., 281., 282.,
      283., 284., 285., 286., 287., 288., 287., 288., 287., 288., 287., 288.,
      343., 344., 345., 346., 347., 348., 349., 350., 351., 352., 351., 352.,
      351., 352., 351., 352., 359., 360., 361., 362., 363., 364., 365., 366.,
      367., 368., 367., 368., 367., 368., 367., 368., 375., 376., 377., 378.,
      379., 380., 381., 382., 383., 384., 383., 384., 383., 384., 383., 384.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 399., 400.,
      399., 400., 399., 400., 407., 408., 409., 410., 411., 412., 413., 414.,
      415., 416., 415., 416., 415., 416., 415., 416., 423., 424., 425., 426.,
      427., 428., 429., 430., 431., 432., 431., 432., 431., 432., 431., 432.,
      423., 424., 425., 426., 427., 428., 429., 430., 431., 432., 431., 432.,
      431., 432., 431., 432., 423., 424., 425., 426., 427., 428., 429., 430.,
      431., 432., 431., 432., 431., 432., 431., 432., 423., 424., 425., 426.,
      427., 428., 429., 430., 431., 432., 431., 432., 431., 432., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 125., 126., 127., 128., 141., 142., 143., 144.,
      253., 254., 255., 256., 269., 270., 271., 272., 285., 286., 287., 288.,
      397., 398., 399., 400., 413., 414., 415., 416., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 269., 270., 271., 272.,
      273., 274., 275., 276., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      285., 286., 287., 288., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      397., 398., 399., 400., 401., 402., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 415., 416., 413., 414., 415., 416.,
      413., 414., 415., 416., 413., 414., 415., 416., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      445., 446., 447., 448., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 541., 542., 543., 544., 541., 542., 543., 544.,
      541., 542., 543., 544., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      557., 558., 559., 560., 561., 562., 563., 564., 565., 566., 567., 568.,
      569., 570., 571., 572., 573., 574., 575., 576., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 557., 558., 559., 560.,
      561., 562., 563., 564., 565., 566., 567., 568., 569., 570., 571., 572.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      573., 574., 575., 576., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      685., 686., 687., 688., 689., 690., 691., 692., 693., 694., 695., 696.,
      697., 698., 699., 700., 701., 702., 703., 704., 701., 702., 703., 704.,
      701., 702., 703., 704., 701., 702., 703., 704., 717., 718., 719., 720.,
      721., 722., 723., 724., 725., 726., 727., 728., 729., 730., 731., 732.,
      733., 734., 735., 736., 733., 734., 735., 736., 733., 734., 735., 736.,
      733., 734., 735., 736., 749., 750., 751., 752., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.,
      781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791., 792.,
      793., 794., 795., 796., 797., 798., 799., 800., 797., 798., 799., 800.,
      797., 798., 799., 800., 797., 798., 799., 800., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      829., 830., 831., 832., 829., 830., 831., 832., 829., 830., 831., 832.,
      829., 830., 831., 832., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      845., 846., 847., 848., 849., 850., 851., 852., 853., 854., 855., 856.,
      857., 858., 859., 860., 861., 862., 863., 864., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 845., 846., 847., 848.,
      849., 850., 851., 852., 853., 854., 855., 856., 857., 858., 859., 860.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      861., 862., 863., 864., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217., 218., 219., 220., 221., 222., 223., 224., 249., 250., 251., 252.,
      253., 254., 255., 256., 281., 282., 283., 284., 285., 286., 287., 288.,
      505., 506., 507., 508., 509., 510., 511., 512., 537., 538., 539., 540.,
      541., 542., 543., 544., 569., 570., 571., 572., 573., 574., 575., 576.,
      793., 794., 795., 796., 797., 798., 799., 800., 825., 826., 827., 828.,
      829., 830., 831., 832., 857., 858., 859., 860., 861., 862., 863., 864.};
  const std::array<int, 4> in_shape = {{3, 9, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  33.,  34.,  35.,  36.,  36.,  36.,  36.,  40.,  41.,  42.,
      43.,  44.,  45.,  45.,  45.,  45.,  49.,  50.,  51.,  52.,  53.,  54.,
      54.,  54.,  54.,  58.,  59.,  60.,  61.,  62.,  63.,  63.,  63.,  63.,
      67.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,  76.,  77.,  78.,
      79.,  80.,  81.,  81.,  81.,  81.,  76.,  77.,  78.,  79.,  80.,  81.,
      81.,  81.,  81.,  76.,  77.,  78.,  79.,  80.,  81.,  81.,  81.,  81.,
      76.,  77.,  78.,  79.,  80.,  81.,  81.,  81.,  81.,  112., 113., 114.,
      115., 116., 117., 117., 117., 117., 121., 122., 123., 124., 125., 126.,
      126., 126., 126., 130., 131., 132., 133., 134., 135., 135., 135., 135.,
      139., 140., 141., 142., 143., 144., 144., 144., 144., 148., 149., 150.,
      151., 152., 153., 153., 153., 153., 157., 158., 159., 160., 161., 162.,
      162., 162., 162., 157., 158., 159., 160., 161., 162., 162., 162., 162.,
      157., 158., 159., 160., 161., 162., 162., 162., 162., 157., 158., 159.,
      160., 161., 162., 162., 162., 162., 193., 194., 195., 196., 197., 198.,
      198., 198., 198., 202., 203., 204., 205., 206., 207., 207., 207., 207.,
      211., 212., 213., 214., 215., 216., 216., 216., 216., 220., 221., 222.,
      223., 224., 225., 225., 225., 225., 229., 230., 231., 232., 233., 234.,
      234., 234., 234., 238., 239., 240., 241., 242., 243., 243., 243., 243.,
      238., 239., 240., 241., 242., 243., 243., 243., 243., 238., 239., 240.,
      241., 242., 243., 243., 243., 243., 238., 239., 240., 241., 242., 243.,
      243., 243., 243.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  70.,  71.,  72.,  79.,  80.,  81.,
      142., 143., 144., 151., 152., 153., 160., 161., 162.,
      223., 224., 225., 232., 233., 234., 241., 242., 243.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 161., 162.,
      161., 162., 161., 162., 161., 162., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 161., 162.,
      161., 162., 161., 162., 161., 162., 223., 224., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 233., 234., 233., 234., 233., 234.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      251., 252., 251., 252., 251., 252., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 269., 270., 269., 270., 269., 270.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 287., 288., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 305., 306., 305., 306., 305., 306.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      323., 324., 323., 324., 323., 324., 313., 314., 315., 316., 317., 318.,
      319., 320., 321., 322., 323., 324., 323., 324., 323., 324., 323., 324.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      323., 324., 323., 324., 323., 324., 313., 314., 315., 316., 317., 318.,
      319., 320., 321., 322., 323., 324., 323., 324., 323., 324., 323., 324.,
      385., 386., 387., 388., 389., 390., 391., 392., 393., 394., 395., 396.,
      395., 396., 395., 396., 395., 396., 403., 404., 405., 406., 407., 408.,
      409., 410., 411., 412., 413., 414., 413., 414., 413., 414., 413., 414.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.,
      431., 432., 431., 432., 431., 432., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 449., 450., 449., 450., 449., 450., 449., 450.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 467., 468., 467., 468., 475., 476., 477., 478., 479., 480.,
      481., 482., 483., 484., 485., 486., 485., 486., 485., 486., 485., 486.,
      475., 476., 477., 478., 479., 480., 481., 482., 483., 484., 485., 486.,
      485., 486., 485., 486., 485., 486., 475., 476., 477., 478., 479., 480.,
      481., 482., 483., 484., 485., 486., 485., 486., 485., 486., 485., 486.,
      475., 476., 477., 478., 479., 480., 481., 482., 483., 484., 485., 486.,
      485., 486., 485., 486., 485., 486.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 139., 140., 141., 142., 143.,
      144., 157., 158., 159., 160., 161., 162., 283., 284., 285., 286.,
      287., 288., 301., 302., 303., 304., 305., 306., 319., 320., 321.,
      322., 323., 324., 445., 446., 447., 448., 449., 450., 463., 464.,
      465., 466., 467., 468., 481., 482., 483., 484., 485., 486.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      141., 142., 143., 144., 141., 142., 143., 144., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 177., 178., 179., 180., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 201., 202., 203., 204.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      213., 214., 215., 216., 213., 214., 215., 216., 213., 214., 215., 216.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      249., 250., 251., 252., 249., 250., 251., 252., 249., 250., 251., 252.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      321., 322., 323., 324., 321., 322., 323., 324., 321., 322., 323., 324.,
      445., 446., 447., 448., 449., 450., 451., 452., 453., 454., 455., 456.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      465., 466., 467., 468., 465., 466., 467., 468., 465., 466., 467., 468.,
      481., 482., 483., 484., 485., 486., 487., 488., 489., 490., 491., 492.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      501., 502., 503., 504., 501., 502., 503., 504., 501., 502., 503., 504.,
      517., 518., 519., 520., 521., 522., 523., 524., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      537., 538., 539., 540., 537., 538., 539., 540., 537., 538., 539., 540.,
      553., 554., 555., 556., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      601., 602., 603., 604., 605., 606., 607., 608., 609., 610., 611., 612.,
      609., 610., 611., 612., 609., 610., 611., 612., 609., 610., 611., 612.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,
      645., 646., 647., 648., 645., 646., 647., 648., 645., 646., 647., 648.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,
      645., 646., 647., 648., 645., 646., 647., 648., 645., 646., 647., 648.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,
      645., 646., 647., 648., 645., 646., 647., 648., 645., 646., 647., 648.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,
      645., 646., 647., 648., 645., 646., 647., 648., 645., 646., 647., 648.,
      769., 770., 771., 772., 773., 774., 775., 776., 777., 778., 779., 780.,
      781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791., 792.,
      789., 790., 791., 792., 789., 790., 791., 792., 789., 790., 791., 792.,
      805., 806., 807., 808., 809., 810., 811., 812., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      825., 826., 827., 828., 825., 826., 827., 828., 825., 826., 827., 828.,
      841., 842., 843., 844., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      877., 878., 879., 880., 881., 882., 883., 884., 885., 886., 887., 888.,
      889., 890., 891., 892., 893., 894., 895., 896., 897., 898., 899., 900.,
      897., 898., 899., 900., 897., 898., 899., 900., 897., 898., 899., 900.,
      913., 914., 915., 916., 917., 918., 919., 920., 921., 922., 923., 924.,
      925., 926., 927., 928., 929., 930., 931., 932., 933., 934., 935., 936.,
      933., 934., 935., 936., 933., 934., 935., 936., 933., 934., 935., 936.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      961., 962., 963., 964., 965., 966., 967., 968., 969., 970., 971., 972.,
      969., 970., 971., 972., 969., 970., 971., 972., 969., 970., 971., 972.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      961., 962., 963., 964., 965., 966., 967., 968., 969., 970., 971., 972.,
      969., 970., 971., 972., 969., 970., 971., 972., 969., 970., 971., 972.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      961., 962., 963., 964., 965., 966., 967., 968., 969., 970., 971., 972.,
      969., 970., 971., 972., 969., 970., 971., 972., 969., 970., 971., 972.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      961., 962., 963., 964., 965., 966., 967., 968., 969., 970., 971., 972.,
      969., 970., 971., 972., 969., 970., 971., 972., 969., 970., 971., 972.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      601., 602., 603., 604., 605., 606., 607., 608., 609., 610., 611., 612.,
      637., 638., 639., 640., 641., 642., 643., 644., 645., 646., 647., 648.,
      889., 890., 891., 892., 893., 894., 895., 896., 897., 898., 899., 900.,
      925., 926., 927., 928., 929., 930., 931., 932., 933., 934., 935., 936.,
      961., 962., 963., 964., 965., 966., 967., 968., 969., 970., 971., 972.};
  const std::array<int, 4> in_shape = {{3, 9, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,  40.,  44.,  45.,
      46.,  47.,  48.,  49.,  50.,  50.,  50.,  50.,  54.,  55.,  56.,  57.,
      58.,  59.,  60.,  60.,  60.,  60.,  64.,  65.,  66.,  67.,  68.,  69.,
      70.,  70.,  70.,  70.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,
      80.,  80.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,
      84.,  85.,  86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,  84.,  85.,
      86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,  84.,  85.,  86.,  87.,
      88.,  89.,  90.,  90.,  90.,  90.,  124., 125., 126., 127., 128., 129.,
      130., 130., 130., 130., 134., 135., 136., 137., 138., 139., 140., 140.,
      140., 140., 144., 145., 146., 147., 148., 149., 150., 150., 150., 150.,
      154., 155., 156., 157., 158., 159., 160., 160., 160., 160., 164., 165.,
      166., 167., 168., 169., 170., 170., 170., 170., 174., 175., 176., 177.,
      178., 179., 180., 180., 180., 180., 174., 175., 176., 177., 178., 179.,
      180., 180., 180., 180., 174., 175., 176., 177., 178., 179., 180., 180.,
      180., 180., 174., 175., 176., 177., 178., 179., 180., 180., 180., 180.,
      214., 215., 216., 217., 218., 219., 220., 220., 220., 220., 224., 225.,
      226., 227., 228., 229., 230., 230., 230., 230., 234., 235., 236., 237.,
      238., 239., 240., 240., 240., 240., 244., 245., 246., 247., 248., 249.,
      250., 250., 250., 250., 254., 255., 256., 257., 258., 259., 260., 260.,
      260., 260., 264., 265., 266., 267., 268., 269., 270., 270., 270., 270.,
      264., 265., 266., 267., 268., 269., 270., 270., 270., 270., 264., 265.,
      266., 267., 268., 269., 270., 270., 270., 270., 264., 265., 266., 267.,
      268., 269., 270., 270., 270., 270.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  77.,  78.,  79.,  80.,  87.,  88.,  89.,  90.,
      157., 158., 159., 160., 167., 168., 169., 170., 177., 178., 179., 180.,
      247., 248., 249., 250., 257., 258., 259., 260., 267., 268., 269., 270.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      167., 168., 169., 170., 171., 172., 173., 174., 175., 176., 177., 178.,
      179., 180., 179., 180., 179., 180., 179., 180., 167., 168., 169., 170.,
      171., 172., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.,
      179., 180., 179., 180., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 257., 258.,
      259., 260., 259., 260., 259., 260., 259., 260., 267., 268., 269., 270.,
      271., 272., 273., 274., 275., 276., 277., 278., 279., 280., 279., 280.,
      279., 280., 279., 280., 287., 288., 289., 290., 291., 292., 293., 294.,
      295., 296., 297., 298., 299., 300., 299., 300., 299., 300., 299., 300.,
      307., 308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 327., 328., 329., 330.,
      331., 332., 333., 334., 335., 336., 337., 338., 339., 340., 339., 340.,
      339., 340., 339., 340., 347., 348., 349., 350., 351., 352., 353., 354.,
      355., 356., 357., 358., 359., 360., 359., 360., 359., 360., 359., 360.,
      347., 348., 349., 350., 351., 352., 353., 354., 355., 356., 357., 358.,
      359., 360., 359., 360., 359., 360., 359., 360., 347., 348., 349., 350.,
      351., 352., 353., 354., 355., 356., 357., 358., 359., 360., 359., 360.,
      359., 360., 359., 360., 347., 348., 349., 350., 351., 352., 353., 354.,
      355., 356., 357., 358., 359., 360., 359., 360., 359., 360., 359., 360.,
      427., 428., 429., 430., 431., 432., 433., 434., 435., 436., 437., 438.,
      439., 440., 439., 440., 439., 440., 439., 440., 447., 448., 449., 450.,
      451., 452., 453., 454., 455., 456., 457., 458., 459., 460., 459., 460.,
      459., 460., 459., 460., 467., 468., 469., 470., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.,
      487., 488., 489., 490., 491., 492., 493., 494., 495., 496., 497., 498.,
      499., 500., 499., 500., 499., 500., 499., 500., 507., 508., 509., 510.,
      511., 512., 513., 514., 515., 516., 517., 518., 519., 520., 519., 520.,
      519., 520., 519., 520., 527., 528., 529., 530., 531., 532., 533., 534.,
      535., 536., 537., 538., 539., 540., 539., 540., 539., 540., 539., 540.,
      527., 528., 529., 530., 531., 532., 533., 534., 535., 536., 537., 538.,
      539., 540., 539., 540., 539., 540., 539., 540., 527., 528., 529., 530.,
      531., 532., 533., 534., 535., 536., 537., 538., 539., 540., 539., 540.,
      539., 540., 539., 540., 527., 528., 529., 530., 531., 532., 533., 534.,
      535., 536., 537., 538., 539., 540., 539., 540., 539., 540., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 153., 154., 155., 156.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      313., 314., 315., 316., 317., 318., 319., 320., 333., 334., 335., 336.,
      337., 338., 339., 340., 353., 354., 355., 356., 357., 358., 359., 360.,
      493., 494., 495., 496., 497., 498., 499., 500., 513., 514., 515., 516.,
      517., 518., 519., 520., 533., 534., 535., 536., 537., 538., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,  141.,  142.,
      143.,  144.,  145.,  146.,  147.,  148.,  149.,  150.,  151.,  152.,
      153.,  154.,  155.,  156.,  157.,  158.,  159.,  160.,  157.,  158.,
      159.,  160.,  157.,  158.,  159.,  160.,  157.,  158.,  159.,  160.,
      173.,  174.,  175.,  176.,  177.,  178.,  179.,  180.,  181.,  182.,
      183.,  184.,  185.,  186.,  187.,  188.,  189.,  190.,  191.,  192.,
      193.,  194.,  195.,  196.,  197.,  198.,  199.,  200.,  197.,  198.,
      199.,  200.,  197.,  198.,  199.,  200.,  197.,  198.,  199.,  200.,
      213.,  214.,  215.,  216.,  217.,  218.,  219.,  220.,  221.,  222.,
      223.,  224.,  225.,  226.,  227.,  228.,  229.,  230.,  231.,  232.,
      233.,  234.,  235.,  236.,  237.,  238.,  239.,  240.,  237.,  238.,
      239.,  240.,  237.,  238.,  239.,  240.,  237.,  238.,  239.,  240.,
      253.,  254.,  255.,  256.,  257.,  258.,  259.,  260.,  261.,  262.,
      263.,  264.,  265.,  266.,  267.,  268.,  269.,  270.,  271.,  272.,
      273.,  274.,  275.,  276.,  277.,  278.,  279.,  280.,  277.,  278.,
      279.,  280.,  277.,  278.,  279.,  280.,  277.,  278.,  279.,  280.,
      293.,  294.,  295.,  296.,  297.,  298.,  299.,  300.,  301.,  302.,
      303.,  304.,  305.,  306.,  307.,  308.,  309.,  310.,  311.,  312.,
      313.,  314.,  315.,  316.,  317.,  318.,  319.,  320.,  317.,  318.,
      319.,  320.,  317.,  318.,  319.,  320.,  317.,  318.,  319.,  320.,
      333.,  334.,  335.,  336.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      333.,  334.,  335.,  336.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      333.,  334.,  335.,  336.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      333.,  334.,  335.,  336.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      493.,  494.,  495.,  496.,  497.,  498.,  499.,  500.,  501.,  502.,
      503.,  504.,  505.,  506.,  507.,  508.,  509.,  510.,  511.,  512.,
      513.,  514.,  515.,  516.,  517.,  518.,  519.,  520.,  517.,  518.,
      519.,  520.,  517.,  518.,  519.,  520.,  517.,  518.,  519.,  520.,
      533.,  534.,  535.,  536.,  537.,  538.,  539.,  540.,  541.,  542.,
      543.,  544.,  545.,  546.,  547.,  548.,  549.,  550.,  551.,  552.,
      553.,  554.,  555.,  556.,  557.,  558.,  559.,  560.,  557.,  558.,
      559.,  560.,  557.,  558.,  559.,  560.,  557.,  558.,  559.,  560.,
      573.,  574.,  575.,  576.,  577.,  578.,  579.,  580.,  581.,  582.,
      583.,  584.,  585.,  586.,  587.,  588.,  589.,  590.,  591.,  592.,
      593.,  594.,  595.,  596.,  597.,  598.,  599.,  600.,  597.,  598.,
      599.,  600.,  597.,  598.,  599.,  600.,  597.,  598.,  599.,  600.,
      613.,  614.,  615.,  616.,  617.,  618.,  619.,  620.,  621.,  622.,
      623.,  624.,  625.,  626.,  627.,  628.,  629.,  630.,  631.,  632.,
      633.,  634.,  635.,  636.,  637.,  638.,  639.,  640.,  637.,  638.,
      639.,  640.,  637.,  638.,  639.,  640.,  637.,  638.,  639.,  640.,
      653.,  654.,  655.,  656.,  657.,  658.,  659.,  660.,  661.,  662.,
      663.,  664.,  665.,  666.,  667.,  668.,  669.,  670.,  671.,  672.,
      673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,  677.,  678.,
      679.,  680.,  677.,  678.,  679.,  680.,  677.,  678.,  679.,  680.,
      693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      853.,  854.,  855.,  856.,  857.,  858.,  859.,  860.,  861.,  862.,
      863.,  864.,  865.,  866.,  867.,  868.,  869.,  870.,  871.,  872.,
      873.,  874.,  875.,  876.,  877.,  878.,  879.,  880.,  877.,  878.,
      879.,  880.,  877.,  878.,  879.,  880.,  877.,  878.,  879.,  880.,
      893.,  894.,  895.,  896.,  897.,  898.,  899.,  900.,  901.,  902.,
      903.,  904.,  905.,  906.,  907.,  908.,  909.,  910.,  911.,  912.,
      913.,  914.,  915.,  916.,  917.,  918.,  919.,  920.,  917.,  918.,
      919.,  920.,  917.,  918.,  919.,  920.,  917.,  918.,  919.,  920.,
      933.,  934.,  935.,  936.,  937.,  938.,  939.,  940.,  941.,  942.,
      943.,  944.,  945.,  946.,  947.,  948.,  949.,  950.,  951.,  952.,
      953.,  954.,  955.,  956.,  957.,  958.,  959.,  960.,  957.,  958.,
      959.,  960.,  957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,
      973.,  974.,  975.,  976.,  977.,  978.,  979.,  980.,  981.,  982.,
      983.,  984.,  985.,  986.,  987.,  988.,  989.,  990.,  991.,  992.,
      993.,  994.,  995.,  996.,  997.,  998.,  999.,  1000., 997.,  998.,
      999.,  1000., 997.,  998.,  999.,  1000., 997.,  998.,  999.,  1000.,
      1013., 1014., 1015., 1016., 1017., 1018., 1019., 1020., 1021., 1022.,
      1023., 1024., 1025., 1026., 1027., 1028., 1029., 1030., 1031., 1032.,
      1033., 1034., 1035., 1036., 1037., 1038., 1039., 1040., 1037., 1038.,
      1039., 1040., 1037., 1038., 1039., 1040., 1037., 1038., 1039., 1040.,
      1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x9x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265.,  266.,  267.,  268.,  269.,  270.,  271.,  272.,  273.,  274.,
      275.,  276.,  277.,  278.,  279.,  280.,  305.,  306.,  307.,  308.,
      309.,  310.,  311.,  312.,  313.,  314.,  315.,  316.,  317.,  318.,
      319.,  320.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  625.,  626.,
      627.,  628.,  629.,  630.,  631.,  632.,  633.,  634.,  635.,  636.,
      637.,  638.,  639.,  640.,  665.,  666.,  667.,  668.,  669.,  670.,
      671.,  672.,  673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,
      705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,  713.,  714.,
      715.,  716.,  717.,  718.,  719.,  720.,  985.,  986.,  987.,  988.,
      989.,  990.,  991.,  992.,  993.,  994.,  995.,  996.,  997.,  998.,
      999.,  1000., 1025., 1026., 1027., 1028., 1029., 1030., 1031., 1032.,
      1033., 1034., 1035., 1036., 1037., 1038., 1039., 1040., 1065., 1066.,
      1067., 1068., 1069., 1070., 1071., 1072., 1073., 1074., 1075., 1076.,
      1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{3, 9, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  29.,  30.,  31.,  32.,  32.,  32.,  32.,  36.,  37.,  38.,  39.,
      40.,  40.,  40.,  40.,  44.,  45.,  46.,  47.,  48.,  48.,  48.,  48.,
      52.,  53.,  54.,  55.,  56.,  56.,  56.,  56.,  60.,  61.,  62.,  63.,
      64.,  64.,  64.,  64.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,
      76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,  76.,  77.,  78.,  79.,
      80.,  80.,  80.,  80.,  76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,
      76.,  77.,  78.,  79.,  80.,  80.,  80.,  80.,  108., 109., 110., 111.,
      112., 112., 112., 112., 116., 117., 118., 119., 120., 120., 120., 120.,
      124., 125., 126., 127., 128., 128., 128., 128., 132., 133., 134., 135.,
      136., 136., 136., 136., 140., 141., 142., 143., 144., 144., 144., 144.,
      148., 149., 150., 151., 152., 152., 152., 152., 156., 157., 158., 159.,
      160., 160., 160., 160., 156., 157., 158., 159., 160., 160., 160., 160.,
      156., 157., 158., 159., 160., 160., 160., 160., 156., 157., 158., 159.,
      160., 160., 160., 160., 188., 189., 190., 191., 192., 192., 192., 192.,
      196., 197., 198., 199., 200., 200., 200., 200., 204., 205., 206., 207.,
      208., 208., 208., 208., 212., 213., 214., 215., 216., 216., 216., 216.,
      220., 221., 222., 223., 224., 224., 224., 224., 228., 229., 230., 231.,
      232., 232., 232., 232., 236., 237., 238., 239., 240., 240., 240., 240.,
      236., 237., 238., 239., 240., 240., 240., 240., 236., 237., 238., 239.,
      240., 240., 240., 240., 236., 237., 238., 239., 240., 240., 240., 240.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  63.,  64.,  71.,  72.,  79.,  80.,  135., 136., 143., 144.,
      151., 152., 159., 160., 215., 216., 223., 224., 231., 232., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,
      63.,  64.,  63.,  64.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,  95.,  96.,  95.,  96.,
      103., 104., 105., 106., 107., 108., 109., 110., 111., 112., 111., 112.,
      111., 112., 111., 112., 119., 120., 121., 122., 123., 124., 125., 126.,
      127., 128., 127., 128., 127., 128., 127., 128., 135., 136., 137., 138.,
      139., 140., 141., 142., 143., 144., 143., 144., 143., 144., 143., 144.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 151., 152., 153., 154., 155., 156., 157., 158.,
      159., 160., 159., 160., 159., 160., 159., 160., 151., 152., 153., 154.,
      155., 156., 157., 158., 159., 160., 159., 160., 159., 160., 159., 160.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 215., 216., 217., 218., 219., 220., 221., 222.,
      223., 224., 223., 224., 223., 224., 223., 224., 231., 232., 233., 234.,
      235., 236., 237., 238., 239., 240., 239., 240., 239., 240., 239., 240.,
      247., 248., 249., 250., 251., 252., 253., 254., 255., 256., 255., 256.,
      255., 256., 255., 256., 263., 264., 265., 266., 267., 268., 269., 270.,
      271., 272., 271., 272., 271., 272., 271., 272., 279., 280., 281., 282.,
      283., 284., 285., 286., 287., 288., 287., 288., 287., 288., 287., 288.,
      295., 296., 297., 298., 299., 300., 301., 302., 303., 304., 303., 304.,
      303., 304., 303., 304., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 311., 312., 313., 314.,
      315., 316., 317., 318., 319., 320., 319., 320., 319., 320., 319., 320.,
      311., 312., 313., 314., 315., 316., 317., 318., 319., 320., 319., 320.,
      319., 320., 319., 320., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 375., 376., 377., 378.,
      379., 380., 381., 382., 383., 384., 383., 384., 383., 384., 383., 384.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 399., 400.,
      399., 400., 399., 400., 407., 408., 409., 410., 411., 412., 413., 414.,
      415., 416., 415., 416., 415., 416., 415., 416., 423., 424., 425., 426.,
      427., 428., 429., 430., 431., 432., 431., 432., 431., 432., 431., 432.,
      439., 440., 441., 442., 443., 444., 445., 446., 447., 448., 447., 448.,
      447., 448., 447., 448., 455., 456., 457., 458., 459., 460., 461., 462.,
      463., 464., 463., 464., 463., 464., 463., 464., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.,
      471., 472., 473., 474., 475., 476., 477., 478., 479., 480., 479., 480.,
      479., 480., 479., 480., 471., 472., 473., 474., 475., 476., 477., 478.,
      479., 480., 479., 480., 479., 480., 479., 480., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 125., 126., 127., 128., 141., 142., 143., 144.,
      157., 158., 159., 160., 269., 270., 271., 272., 285., 286., 287., 288.,
      301., 302., 303., 304., 317., 318., 319., 320., 429., 430., 431., 432.,
      445., 446., 447., 448., 461., 462., 463., 464., 477., 478., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 127., 128., 125., 126., 127., 128.,
      125., 126., 127., 128., 125., 126., 127., 128., 141., 142., 143., 144.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 157., 158., 159., 160.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      181., 182., 183., 184., 185., 186., 187., 188., 189., 190., 191., 192.,
      189., 190., 191., 192., 189., 190., 191., 192., 189., 190., 191., 192.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 221., 222., 223., 224., 221., 222., 223., 224.,
      221., 222., 223., 224., 221., 222., 223., 224., 237., 238., 239., 240.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 253., 254., 255., 256., 253., 254., 255., 256.,
      253., 254., 255., 256., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      285., 286., 287., 288., 285., 286., 287., 288., 285., 286., 287., 288.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 301., 302., 303., 304.,
      305., 306., 307., 308., 309., 310., 311., 312., 313., 314., 315., 316.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 317., 318., 319., 320.,
      301., 302., 303., 304., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      317., 318., 319., 320., 317., 318., 319., 320., 429., 430., 431., 432.,
      433., 434., 435., 436., 437., 438., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 445., 446., 447., 448., 445., 446., 447., 448.,
      445., 446., 447., 448., 461., 462., 463., 464., 465., 466., 467., 468.,
      469., 470., 471., 472., 473., 474., 475., 476., 477., 478., 479., 480.,
      477., 478., 479., 480., 477., 478., 479., 480., 477., 478., 479., 480.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      505., 506., 507., 508., 509., 510., 511., 512., 509., 510., 511., 512.,
      509., 510., 511., 512., 509., 510., 511., 512., 525., 526., 527., 528.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      541., 542., 543., 544., 541., 542., 543., 544., 541., 542., 543., 544.,
      541., 542., 543., 544., 557., 558., 559., 560., 561., 562., 563., 564.,
      565., 566., 567., 568., 569., 570., 571., 572., 573., 574., 575., 576.,
      573., 574., 575., 576., 573., 574., 575., 576., 573., 574., 575., 576.,
      589., 590., 591., 592., 593., 594., 595., 596., 597., 598., 599., 600.,
      601., 602., 603., 604., 605., 606., 607., 608., 605., 606., 607., 608.,
      605., 606., 607., 608., 605., 606., 607., 608., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 621., 622., 623., 624., 625., 626., 627., 628.,
      629., 630., 631., 632., 633., 634., 635., 636., 637., 638., 639., 640.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      621., 622., 623., 624., 625., 626., 627., 628., 629., 630., 631., 632.,
      633., 634., 635., 636., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 637., 638., 639., 640., 621., 622., 623., 624.,
      625., 626., 627., 628., 629., 630., 631., 632., 633., 634., 635., 636.,
      637., 638., 639., 640., 637., 638., 639., 640., 637., 638., 639., 640.,
      637., 638., 639., 640., 749., 750., 751., 752., 753., 754., 755., 756.,
      757., 758., 759., 760., 761., 762., 763., 764., 765., 766., 767., 768.,
      765., 766., 767., 768., 765., 766., 767., 768., 765., 766., 767., 768.,
      781., 782., 783., 784., 785., 786., 787., 788., 789., 790., 791., 792.,
      793., 794., 795., 796., 797., 798., 799., 800., 797., 798., 799., 800.,
      797., 798., 799., 800., 797., 798., 799., 800., 813., 814., 815., 816.,
      817., 818., 819., 820., 821., 822., 823., 824., 825., 826., 827., 828.,
      829., 830., 831., 832., 829., 830., 831., 832., 829., 830., 831., 832.,
      829., 830., 831., 832., 845., 846., 847., 848., 849., 850., 851., 852.,
      853., 854., 855., 856., 857., 858., 859., 860., 861., 862., 863., 864.,
      861., 862., 863., 864., 861., 862., 863., 864., 861., 862., 863., 864.,
      877., 878., 879., 880., 881., 882., 883., 884., 885., 886., 887., 888.,
      889., 890., 891., 892., 893., 894., 895., 896., 893., 894., 895., 896.,
      893., 894., 895., 896., 893., 894., 895., 896., 909., 910., 911., 912.,
      913., 914., 915., 916., 917., 918., 919., 920., 921., 922., 923., 924.,
      925., 926., 927., 928., 925., 926., 927., 928., 925., 926., 927., 928.,
      925., 926., 927., 928., 941., 942., 943., 944., 945., 946., 947., 948.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.,
      941., 942., 943., 944., 945., 946., 947., 948., 949., 950., 951., 952.,
      953., 954., 955., 956., 957., 958., 959., 960., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 941., 942., 943., 944.,
      945., 946., 947., 948., 949., 950., 951., 952., 953., 954., 955., 956.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.,
      957., 958., 959., 960., 941., 942., 943., 944., 945., 946., 947., 948.,
      949., 950., 951., 952., 953., 954., 955., 956., 957., 958., 959., 960.,
      957., 958., 959., 960., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217., 218., 219., 220., 221., 222., 223., 224., 249., 250., 251., 252.,
      253., 254., 255., 256., 281., 282., 283., 284., 285., 286., 287., 288.,
      313., 314., 315., 316., 317., 318., 319., 320., 537., 538., 539., 540.,
      541., 542., 543., 544., 569., 570., 571., 572., 573., 574., 575., 576.,
      601., 602., 603., 604., 605., 606., 607., 608., 633., 634., 635., 636.,
      637., 638., 639., 640., 857., 858., 859., 860., 861., 862., 863., 864.,
      889., 890., 891., 892., 893., 894., 895., 896., 921., 922., 923., 924.,
      925., 926., 927., 928., 953., 954., 955., 956., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31.,  32.,  33.,  34.,  35.,  36.,  36.,  36.,  36.,  40.,  41.,  42.,
      43.,  44.,  45.,  45.,  45.,  45.,  49.,  50.,  51.,  52.,  53.,  54.,
      54.,  54.,  54.,  58.,  59.,  60.,  61.,  62.,  63.,  63.,  63.,  63.,
      67.,  68.,  69.,  70.,  71.,  72.,  72.,  72.,  72.,  76.,  77.,  78.,
      79.,  80.,  81.,  81.,  81.,  81.,  85.,  86.,  87.,  88.,  89.,  90.,
      90.,  90.,  90.,  85.,  86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,
      85.,  86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,  85.,  86.,  87.,
      88.,  89.,  90.,  90.,  90.,  90.,  121., 122., 123., 124., 125., 126.,
      126., 126., 126., 130., 131., 132., 133., 134., 135., 135., 135., 135.,
      139., 140., 141., 142., 143., 144., 144., 144., 144., 148., 149., 150.,
      151., 152., 153., 153., 153., 153., 157., 158., 159., 160., 161., 162.,
      162., 162., 162., 166., 167., 168., 169., 170., 171., 171., 171., 171.,
      175., 176., 177., 178., 179., 180., 180., 180., 180., 175., 176., 177.,
      178., 179., 180., 180., 180., 180., 175., 176., 177., 178., 179., 180.,
      180., 180., 180., 175., 176., 177., 178., 179., 180., 180., 180., 180.,
      211., 212., 213., 214., 215., 216., 216., 216., 216., 220., 221., 222.,
      223., 224., 225., 225., 225., 225., 229., 230., 231., 232., 233., 234.,
      234., 234., 234., 238., 239., 240., 241., 242., 243., 243., 243., 243.,
      247., 248., 249., 250., 251., 252., 252., 252., 252., 256., 257., 258.,
      259., 260., 261., 261., 261., 261., 265., 266., 267., 268., 269., 270.,
      270., 270., 270., 265., 266., 267., 268., 269., 270., 270., 270., 270.,
      265., 266., 267., 268., 269., 270., 270., 270., 270., 265., 266., 267.,
      268., 269., 270., 270., 270., 270.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x9x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  70.,  71.,  72.,  79.,  80.,  81.,  88.,  89.,  90.,
      151., 152., 153., 160., 161., 162., 169., 170., 171., 178., 179., 180.,
      241., 242., 243., 250., 251., 252., 259., 260., 261., 268., 269., 270.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      71.,  72.,  71.,  72.,  71.,  72.,  79.,  80.,  81.,  82.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  89.,  90.,  89.,  90.,
      97.,  98.,  99.,  100., 101., 102., 103., 104., 105., 106., 107., 108.,
      107., 108., 107., 108., 107., 108., 115., 116., 117., 118., 119., 120.,
      121., 122., 123., 124., 125., 126., 125., 126., 125., 126., 125., 126.,
      133., 134., 135., 136., 137., 138., 139., 140., 141., 142., 143., 144.,
      143., 144., 143., 144., 143., 144., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 161., 162., 161., 162., 161., 162.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 179., 180., 179., 180., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 179., 180., 179., 180., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      241., 242., 243., 244., 245., 246., 247., 248., 249., 250., 251., 252.,
      251., 252., 251., 252., 251., 252., 259., 260., 261., 262., 263., 264.,
      265., 266., 267., 268., 269., 270., 269., 270., 269., 270., 269., 270.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.,
      287., 288., 287., 288., 287., 288., 295., 296., 297., 298., 299., 300.,
      301., 302., 303., 304., 305., 306., 305., 306., 305., 306., 305., 306.,
      313., 314., 315., 316., 317., 318., 319., 320., 321., 322., 323., 324.,
      323., 324., 323., 324., 323., 324., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 341., 342., 341., 342., 341., 342., 341., 342.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      359., 360., 359., 360., 359., 360., 349., 350., 351., 352., 353., 354.,
      355., 356., 357., 358., 359., 360., 359., 360., 359., 360., 359., 360.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      359., 360., 359., 360., 359., 360., 349., 350., 351., 352., 353., 354.,
      355., 356., 357., 358., 359., 360., 359., 360., 359., 360., 359., 360.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.,
      431., 432., 431., 432., 431., 432., 439., 440., 441., 442., 443., 444.,
      445., 446., 447., 448., 449., 450., 449., 450., 449., 450., 449., 450.,
      457., 458., 459., 460., 461., 462., 463., 464., 465., 466., 467., 468.,
      467., 468., 467., 468., 467., 468., 475., 476., 477., 478., 479., 480.,
      481., 482., 483., 484., 485., 486., 485., 486., 485., 486., 485., 486.,
      493., 494., 495., 496., 497., 498., 499., 500., 501., 502., 503., 504.,
      503., 504., 503., 504., 503., 504., 511., 512., 513., 514., 515., 516.,
      517., 518., 519., 520., 521., 522., 521., 522., 521., 522., 521., 522.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      539., 540., 539., 540., 539., 540., 529., 530., 531., 532., 533., 534.,
      535., 536., 537., 538., 539., 540., 539., 540., 539., 540., 539., 540.,
      529., 530., 531., 532., 533., 534., 535., 536., 537., 538., 539., 540.,
      539., 540., 539., 540., 539., 540., 529., 530., 531., 532., 533., 534.,
      535., 536., 537., 538., 539., 540., 539., 540., 539., 540., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x9x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 123., 124., 125., 126., 139., 140., 141., 142., 143., 144.,
      157., 158., 159., 160., 161., 162., 175., 176., 177., 178., 179., 180.,
      301., 302., 303., 304., 305., 306., 319., 320., 321., 322., 323., 324.,
      337., 338., 339., 340., 341., 342., 355., 356., 357., 358., 359., 360.,
      481., 482., 483., 484., 485., 486., 499., 500., 501., 502., 503., 504.,
      517., 518., 519., 520., 521., 522., 535., 536., 537., 538., 539., 540.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121.,  122.,  123.,  124.,  125.,  126.,  127.,  128.,  129.,  130.,
      131.,  132.,  133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,
      141.,  142.,  143.,  144.,  141.,  142.,  143.,  144.,  141.,  142.,
      143.,  144.,  141.,  142.,  143.,  144.,  157.,  158.,  159.,  160.,
      161.,  162.,  163.,  164.,  165.,  166.,  167.,  168.,  169.,  170.,
      171.,  172.,  173.,  174.,  175.,  176.,  177.,  178.,  179.,  180.,
      177.,  178.,  179.,  180.,  177.,  178.,  179.,  180.,  177.,  178.,
      179.,  180.,  193.,  194.,  195.,  196.,  197.,  198.,  199.,  200.,
      201.,  202.,  203.,  204.,  205.,  206.,  207.,  208.,  209.,  210.,
      211.,  212.,  213.,  214.,  215.,  216.,  213.,  214.,  215.,  216.,
      213.,  214.,  215.,  216.,  213.,  214.,  215.,  216.,  229.,  230.,
      231.,  232.,  233.,  234.,  235.,  236.,  237.,  238.,  239.,  240.,
      241.,  242.,  243.,  244.,  245.,  246.,  247.,  248.,  249.,  250.,
      251.,  252.,  249.,  250.,  251.,  252.,  249.,  250.,  251.,  252.,
      249.,  250.,  251.,  252.,  265.,  266.,  267.,  268.,  269.,  270.,
      271.,  272.,  273.,  274.,  275.,  276.,  277.,  278.,  279.,  280.,
      281.,  282.,  283.,  284.,  285.,  286.,  287.,  288.,  285.,  286.,
      287.,  288.,  285.,  286.,  287.,  288.,  285.,  286.,  287.,  288.,
      301.,  302.,  303.,  304.,  305.,  306.,  307.,  308.,  309.,  310.,
      311.,  312.,  313.,  314.,  315.,  316.,  317.,  318.,  319.,  320.,
      321.,  322.,  323.,  324.,  321.,  322.,  323.,  324.,  321.,  322.,
      323.,  324.,  321.,  322.,  323.,  324.,  337.,  338.,  339.,  340.,
      341.,  342.,  343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,
      351.,  352.,  353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,
      357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  337.,  338.,  339.,  340.,  341.,  342.,  343.,  344.,
      345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,  353.,  354.,
      355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,  337.,  338.,
      339.,  340.,  341.,  342.,  343.,  344.,  345.,  346.,  347.,  348.,
      349.,  350.,  351.,  352.,  353.,  354.,  355.,  356.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      357.,  358.,  359.,  360.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      481.,  482.,  483.,  484.,  485.,  486.,  487.,  488.,  489.,  490.,
      491.,  492.,  493.,  494.,  495.,  496.,  497.,  498.,  499.,  500.,
      501.,  502.,  503.,  504.,  501.,  502.,  503.,  504.,  501.,  502.,
      503.,  504.,  501.,  502.,  503.,  504.,  517.,  518.,  519.,  520.,
      521.,  522.,  523.,  524.,  525.,  526.,  527.,  528.,  529.,  530.,
      531.,  532.,  533.,  534.,  535.,  536.,  537.,  538.,  539.,  540.,
      537.,  538.,  539.,  540.,  537.,  538.,  539.,  540.,  537.,  538.,
      539.,  540.,  553.,  554.,  555.,  556.,  557.,  558.,  559.,  560.,
      561.,  562.,  563.,  564.,  565.,  566.,  567.,  568.,  569.,  570.,
      571.,  572.,  573.,  574.,  575.,  576.,  573.,  574.,  575.,  576.,
      573.,  574.,  575.,  576.,  573.,  574.,  575.,  576.,  589.,  590.,
      591.,  592.,  593.,  594.,  595.,  596.,  597.,  598.,  599.,  600.,
      601.,  602.,  603.,  604.,  605.,  606.,  607.,  608.,  609.,  610.,
      611.,  612.,  609.,  610.,  611.,  612.,  609.,  610.,  611.,  612.,
      609.,  610.,  611.,  612.,  625.,  626.,  627.,  628.,  629.,  630.,
      631.,  632.,  633.,  634.,  635.,  636.,  637.,  638.,  639.,  640.,
      641.,  642.,  643.,  644.,  645.,  646.,  647.,  648.,  645.,  646.,
      647.,  648.,  645.,  646.,  647.,  648.,  645.,  646.,  647.,  648.,
      661.,  662.,  663.,  664.,  665.,  666.,  667.,  668.,  669.,  670.,
      671.,  672.,  673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,
      681.,  682.,  683.,  684.,  681.,  682.,  683.,  684.,  681.,  682.,
      683.,  684.,  681.,  682.,  683.,  684.,  697.,  698.,  699.,  700.,
      701.,  702.,  703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,
      711.,  712.,  713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,
      717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  697.,  698.,  699.,  700.,  701.,  702.,  703.,  704.,
      705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,  713.,  714.,
      715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,  697.,  698.,
      699.,  700.,  701.,  702.,  703.,  704.,  705.,  706.,  707.,  708.,
      709.,  710.,  711.,  712.,  713.,  714.,  715.,  716.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      717.,  718.,  719.,  720.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      841.,  842.,  843.,  844.,  845.,  846.,  847.,  848.,  849.,  850.,
      851.,  852.,  853.,  854.,  855.,  856.,  857.,  858.,  859.,  860.,
      861.,  862.,  863.,  864.,  861.,  862.,  863.,  864.,  861.,  862.,
      863.,  864.,  861.,  862.,  863.,  864.,  877.,  878.,  879.,  880.,
      881.,  882.,  883.,  884.,  885.,  886.,  887.,  888.,  889.,  890.,
      891.,  892.,  893.,  894.,  895.,  896.,  897.,  898.,  899.,  900.,
      897.,  898.,  899.,  900.,  897.,  898.,  899.,  900.,  897.,  898.,
      899.,  900.,  913.,  914.,  915.,  916.,  917.,  918.,  919.,  920.,
      921.,  922.,  923.,  924.,  925.,  926.,  927.,  928.,  929.,  930.,
      931.,  932.,  933.,  934.,  935.,  936.,  933.,  934.,  935.,  936.,
      933.,  934.,  935.,  936.,  933.,  934.,  935.,  936.,  949.,  950.,
      951.,  952.,  953.,  954.,  955.,  956.,  957.,  958.,  959.,  960.,
      961.,  962.,  963.,  964.,  965.,  966.,  967.,  968.,  969.,  970.,
      971.,  972.,  969.,  970.,  971.,  972.,  969.,  970.,  971.,  972.,
      969.,  970.,  971.,  972.,  985.,  986.,  987.,  988.,  989.,  990.,
      991.,  992.,  993.,  994.,  995.,  996.,  997.,  998.,  999.,  1000.,
      1001., 1002., 1003., 1004., 1005., 1006., 1007., 1008., 1005., 1006.,
      1007., 1008., 1005., 1006., 1007., 1008., 1005., 1006., 1007., 1008.,
      1021., 1022., 1023., 1024., 1025., 1026., 1027., 1028., 1029., 1030.,
      1031., 1032., 1033., 1034., 1035., 1036., 1037., 1038., 1039., 1040.,
      1041., 1042., 1043., 1044., 1041., 1042., 1043., 1044., 1041., 1042.,
      1043., 1044., 1041., 1042., 1043., 1044., 1057., 1058., 1059., 1060.,
      1061., 1062., 1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070.,
      1071., 1072., 1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080.,
      1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1057., 1058., 1059., 1060., 1061., 1062., 1063., 1064.,
      1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072., 1073., 1074.,
      1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080., 1057., 1058.,
      1059., 1060., 1061., 1062., 1063., 1064., 1065., 1066., 1067., 1068.,
      1069., 1070., 1071., 1072., 1073., 1074., 1075., 1076., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1077., 1078., 1079., 1080., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x9x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241.,  242.,  243.,  244.,  245.,  246.,  247.,  248.,  249.,  250.,
      251.,  252.,  277.,  278.,  279.,  280.,  281.,  282.,  283.,  284.,
      285.,  286.,  287.,  288.,  313.,  314.,  315.,  316.,  317.,  318.,
      319.,  320.,  321.,  322.,  323.,  324.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  601.,  602.,
      603.,  604.,  605.,  606.,  607.,  608.,  609.,  610.,  611.,  612.,
      637.,  638.,  639.,  640.,  641.,  642.,  643.,  644.,  645.,  646.,
      647.,  648.,  673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,
      681.,  682.,  683.,  684.,  709.,  710.,  711.,  712.,  713.,  714.,
      715.,  716.,  717.,  718.,  719.,  720.,  961.,  962.,  963.,  964.,
      965.,  966.,  967.,  968.,  969.,  970.,  971.,  972.,  997.,  998.,
      999.,  1000., 1001., 1002., 1003., 1004., 1005., 1006., 1007., 1008.,
      1033., 1034., 1035., 1036., 1037., 1038., 1039., 1040., 1041., 1042.,
      1043., 1044., 1069., 1070., 1071., 1072., 1073., 1074., 1075., 1076.,
      1077., 1078., 1079., 1080.};
  const std::array<int, 4> in_shape = {{3, 10, 9, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  35.,  36.,  37.,  38.,  39.,  40.,  40.,  40.,  40.,  44.,  45.,
      46.,  47.,  48.,  49.,  50.,  50.,  50.,  50.,  54.,  55.,  56.,  57.,
      58.,  59.,  60.,  60.,  60.,  60.,  64.,  65.,  66.,  67.,  68.,  69.,
      70.,  70.,  70.,  70.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  80.,
      80.,  80.,  84.,  85.,  86.,  87.,  88.,  89.,  90.,  90.,  90.,  90.,
      94.,  95.,  96.,  97.,  98.,  99.,  100., 100., 100., 100., 94.,  95.,
      96.,  97.,  98.,  99.,  100., 100., 100., 100., 94.,  95.,  96.,  97.,
      98.,  99.,  100., 100., 100., 100., 94.,  95.,  96.,  97.,  98.,  99.,
      100., 100., 100., 100., 134., 135., 136., 137., 138., 139., 140., 140.,
      140., 140., 144., 145., 146., 147., 148., 149., 150., 150., 150., 150.,
      154., 155., 156., 157., 158., 159., 160., 160., 160., 160., 164., 165.,
      166., 167., 168., 169., 170., 170., 170., 170., 174., 175., 176., 177.,
      178., 179., 180., 180., 180., 180., 184., 185., 186., 187., 188., 189.,
      190., 190., 190., 190., 194., 195., 196., 197., 198., 199., 200., 200.,
      200., 200., 194., 195., 196., 197., 198., 199., 200., 200., 200., 200.,
      194., 195., 196., 197., 198., 199., 200., 200., 200., 200., 194., 195.,
      196., 197., 198., 199., 200., 200., 200., 200., 234., 235., 236., 237.,
      238., 239., 240., 240., 240., 240., 244., 245., 246., 247., 248., 249.,
      250., 250., 250., 250., 254., 255., 256., 257., 258., 259., 260., 260.,
      260., 260., 264., 265., 266., 267., 268., 269., 270., 270., 270., 270.,
      274., 275., 276., 277., 278., 279., 280., 280., 280., 280., 284., 285.,
      286., 287., 288., 289., 290., 290., 290., 290., 294., 295., 296., 297.,
      298., 299., 300., 300., 300., 300., 294., 295., 296., 297., 298., 299.,
      300., 300., 300., 300., 294., 295., 296., 297., 298., 299., 300., 300.,
      300., 300., 294., 295., 296., 297., 298., 299., 300., 300., 300., 300.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  77.,  78.,  79.,  80.,  87.,  88.,  89.,  90.,
      97.,  98.,  99.,  100., 167., 168., 169., 170., 177., 178., 179., 180.,
      187., 188., 189., 190., 197., 198., 199., 200., 267., 268., 269., 270.,
      277., 278., 279., 280., 287., 288., 289., 290., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,
      79.,  80.,  79.,  80.,  79.,  80.,  79.,  80.,  87.,  88.,  89.,  90.,
      91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100., 99.,  100.,
      99.,  100., 99.,  100., 107., 108., 109., 110., 111., 112., 113., 114.,
      115., 116., 117., 118., 119., 120., 119., 120., 119., 120., 119., 120.,
      127., 128., 129., 130., 131., 132., 133., 134., 135., 136., 137., 138.,
      139., 140., 139., 140., 139., 140., 139., 140., 147., 148., 149., 150.,
      151., 152., 153., 154., 155., 156., 157., 158., 159., 160., 159., 160.,
      159., 160., 159., 160., 167., 168., 169., 170., 171., 172., 173., 174.,
      175., 176., 177., 178., 179., 180., 179., 180., 179., 180., 179., 180.,
      187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197., 198.,
      199., 200., 199., 200., 199., 200., 199., 200., 187., 188., 189., 190.,
      191., 192., 193., 194., 195., 196., 197., 198., 199., 200., 199., 200.,
      199., 200., 199., 200., 187., 188., 189., 190., 191., 192., 193., 194.,
      195., 196., 197., 198., 199., 200., 199., 200., 199., 200., 199., 200.,
      187., 188., 189., 190., 191., 192., 193., 194., 195., 196., 197., 198.,
      199., 200., 199., 200., 199., 200., 199., 200., 267., 268., 269., 270.,
      271., 272., 273., 274., 275., 276., 277., 278., 279., 280., 279., 280.,
      279., 280., 279., 280., 287., 288., 289., 290., 291., 292., 293., 294.,
      295., 296., 297., 298., 299., 300., 299., 300., 299., 300., 299., 300.,
      307., 308., 309., 310., 311., 312., 313., 314., 315., 316., 317., 318.,
      319., 320., 319., 320., 319., 320., 319., 320., 327., 328., 329., 330.,
      331., 332., 333., 334., 335., 336., 337., 338., 339., 340., 339., 340.,
      339., 340., 339., 340., 347., 348., 349., 350., 351., 352., 353., 354.,
      355., 356., 357., 358., 359., 360., 359., 360., 359., 360., 359., 360.,
      367., 368., 369., 370., 371., 372., 373., 374., 375., 376., 377., 378.,
      379., 380., 379., 380., 379., 380., 379., 380., 387., 388., 389., 390.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 399., 400.,
      399., 400., 399., 400., 387., 388., 389., 390., 391., 392., 393., 394.,
      395., 396., 397., 398., 399., 400., 399., 400., 399., 400., 399., 400.,
      387., 388., 389., 390., 391., 392., 393., 394., 395., 396., 397., 398.,
      399., 400., 399., 400., 399., 400., 399., 400., 387., 388., 389., 390.,
      391., 392., 393., 394., 395., 396., 397., 398., 399., 400., 399., 400.,
      399., 400., 399., 400., 467., 468., 469., 470., 471., 472., 473., 474.,
      475., 476., 477., 478., 479., 480., 479., 480., 479., 480., 479., 480.,
      487., 488., 489., 490., 491., 492., 493., 494., 495., 496., 497., 498.,
      499., 500., 499., 500., 499., 500., 499., 500., 507., 508., 509., 510.,
      511., 512., 513., 514., 515., 516., 517., 518., 519., 520., 519., 520.,
      519., 520., 519., 520., 527., 528., 529., 530., 531., 532., 533., 534.,
      535., 536., 537., 538., 539., 540., 539., 540., 539., 540., 539., 540.,
      547., 548., 549., 550., 551., 552., 553., 554., 555., 556., 557., 558.,
      559., 560., 559., 560., 559., 560., 559., 560., 567., 568., 569., 570.,
      571., 572., 573., 574., 575., 576., 577., 578., 579., 580., 579., 580.,
      579., 580., 579., 580., 587., 588., 589., 590., 591., 592., 593., 594.,
      595., 596., 597., 598., 599., 600., 599., 600., 599., 600., 599., 600.,
      587., 588., 589., 590., 591., 592., 593., 594., 595., 596., 597., 598.,
      599., 600., 599., 600., 599., 600., 599., 600., 587., 588., 589., 590.,
      591., 592., 593., 594., 595., 596., 597., 598., 599., 600., 599., 600.,
      599., 600., 599., 600., 587., 588., 589., 590., 591., 592., 593., 594.,
      595., 596., 597., 598., 599., 600., 599., 600., 599., 600., 599., 600.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 137., 138., 139., 140., 153., 154., 155., 156.,
      157., 158., 159., 160., 173., 174., 175., 176., 177., 178., 179., 180.,
      193., 194., 195., 196., 197., 198., 199., 200., 333., 334., 335., 336.,
      337., 338., 339., 340., 353., 354., 355., 356., 357., 358., 359., 360.,
      373., 374., 375., 376., 377., 378., 379., 380., 393., 394., 395., 396.,
      397., 398., 399., 400., 533., 534., 535., 536., 537., 538., 539., 540.,
      553., 554., 555., 556., 557., 558., 559., 560., 573., 574., 575., 576.,
      577., 578., 579., 580., 593., 594., 595., 596., 597., 598., 599., 600.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, SAME3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133.,  134.,  135.,  136.,  137.,  138.,  139.,  140.,  141.,  142.,
      143.,  144.,  145.,  146.,  147.,  148.,  149.,  150.,  151.,  152.,
      153.,  154.,  155.,  156.,  157.,  158.,  159.,  160.,  157.,  158.,
      159.,  160.,  157.,  158.,  159.,  160.,  157.,  158.,  159.,  160.,
      173.,  174.,  175.,  176.,  177.,  178.,  179.,  180.,  181.,  182.,
      183.,  184.,  185.,  186.,  187.,  188.,  189.,  190.,  191.,  192.,
      193.,  194.,  195.,  196.,  197.,  198.,  199.,  200.,  197.,  198.,
      199.,  200.,  197.,  198.,  199.,  200.,  197.,  198.,  199.,  200.,
      213.,  214.,  215.,  216.,  217.,  218.,  219.,  220.,  221.,  222.,
      223.,  224.,  225.,  226.,  227.,  228.,  229.,  230.,  231.,  232.,
      233.,  234.,  235.,  236.,  237.,  238.,  239.,  240.,  237.,  238.,
      239.,  240.,  237.,  238.,  239.,  240.,  237.,  238.,  239.,  240.,
      253.,  254.,  255.,  256.,  257.,  258.,  259.,  260.,  261.,  262.,
      263.,  264.,  265.,  266.,  267.,  268.,  269.,  270.,  271.,  272.,
      273.,  274.,  275.,  276.,  277.,  278.,  279.,  280.,  277.,  278.,
      279.,  280.,  277.,  278.,  279.,  280.,  277.,  278.,  279.,  280.,
      293.,  294.,  295.,  296.,  297.,  298.,  299.,  300.,  301.,  302.,
      303.,  304.,  305.,  306.,  307.,  308.,  309.,  310.,  311.,  312.,
      313.,  314.,  315.,  316.,  317.,  318.,  319.,  320.,  317.,  318.,
      319.,  320.,  317.,  318.,  319.,  320.,  317.,  318.,  319.,  320.,
      333.,  334.,  335.,  336.,  337.,  338.,  339.,  340.,  341.,  342.,
      343.,  344.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  357.,  358.,
      359.,  360.,  357.,  358.,  359.,  360.,  357.,  358.,  359.,  360.,
      373.,  374.,  375.,  376.,  377.,  378.,  379.,  380.,  381.,  382.,
      383.,  384.,  385.,  386.,  387.,  388.,  389.,  390.,  391.,  392.,
      393.,  394.,  395.,  396.,  397.,  398.,  399.,  400.,  397.,  398.,
      399.,  400.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      373.,  374.,  375.,  376.,  377.,  378.,  379.,  380.,  381.,  382.,
      383.,  384.,  385.,  386.,  387.,  388.,  389.,  390.,  391.,  392.,
      393.,  394.,  395.,  396.,  397.,  398.,  399.,  400.,  397.,  398.,
      399.,  400.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      373.,  374.,  375.,  376.,  377.,  378.,  379.,  380.,  381.,  382.,
      383.,  384.,  385.,  386.,  387.,  388.,  389.,  390.,  391.,  392.,
      393.,  394.,  395.,  396.,  397.,  398.,  399.,  400.,  397.,  398.,
      399.,  400.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      373.,  374.,  375.,  376.,  377.,  378.,  379.,  380.,  381.,  382.,
      383.,  384.,  385.,  386.,  387.,  388.,  389.,  390.,  391.,  392.,
      393.,  394.,  395.,  396.,  397.,  398.,  399.,  400.,  397.,  398.,
      399.,  400.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      533.,  534.,  535.,  536.,  537.,  538.,  539.,  540.,  541.,  542.,
      543.,  544.,  545.,  546.,  547.,  548.,  549.,  550.,  551.,  552.,
      553.,  554.,  555.,  556.,  557.,  558.,  559.,  560.,  557.,  558.,
      559.,  560.,  557.,  558.,  559.,  560.,  557.,  558.,  559.,  560.,
      573.,  574.,  575.,  576.,  577.,  578.,  579.,  580.,  581.,  582.,
      583.,  584.,  585.,  586.,  587.,  588.,  589.,  590.,  591.,  592.,
      593.,  594.,  595.,  596.,  597.,  598.,  599.,  600.,  597.,  598.,
      599.,  600.,  597.,  598.,  599.,  600.,  597.,  598.,  599.,  600.,
      613.,  614.,  615.,  616.,  617.,  618.,  619.,  620.,  621.,  622.,
      623.,  624.,  625.,  626.,  627.,  628.,  629.,  630.,  631.,  632.,
      633.,  634.,  635.,  636.,  637.,  638.,  639.,  640.,  637.,  638.,
      639.,  640.,  637.,  638.,  639.,  640.,  637.,  638.,  639.,  640.,
      653.,  654.,  655.,  656.,  657.,  658.,  659.,  660.,  661.,  662.,
      663.,  664.,  665.,  666.,  667.,  668.,  669.,  670.,  671.,  672.,
      673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,  677.,  678.,
      679.,  680.,  677.,  678.,  679.,  680.,  677.,  678.,  679.,  680.,
      693.,  694.,  695.,  696.,  697.,  698.,  699.,  700.,  701.,  702.,
      703.,  704.,  705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,
      713.,  714.,  715.,  716.,  717.,  718.,  719.,  720.,  717.,  718.,
      719.,  720.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      733.,  734.,  735.,  736.,  737.,  738.,  739.,  740.,  741.,  742.,
      743.,  744.,  745.,  746.,  747.,  748.,  749.,  750.,  751.,  752.,
      753.,  754.,  755.,  756.,  757.,  758.,  759.,  760.,  757.,  758.,
      759.,  760.,  757.,  758.,  759.,  760.,  757.,  758.,  759.,  760.,
      773.,  774.,  775.,  776.,  777.,  778.,  779.,  780.,  781.,  782.,
      783.,  784.,  785.,  786.,  787.,  788.,  789.,  790.,  791.,  792.,
      793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,  797.,  798.,
      799.,  800.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      773.,  774.,  775.,  776.,  777.,  778.,  779.,  780.,  781.,  782.,
      783.,  784.,  785.,  786.,  787.,  788.,  789.,  790.,  791.,  792.,
      793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,  797.,  798.,
      799.,  800.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      773.,  774.,  775.,  776.,  777.,  778.,  779.,  780.,  781.,  782.,
      783.,  784.,  785.,  786.,  787.,  788.,  789.,  790.,  791.,  792.,
      793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,  797.,  798.,
      799.,  800.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      773.,  774.,  775.,  776.,  777.,  778.,  779.,  780.,  781.,  782.,
      783.,  784.,  785.,  786.,  787.,  788.,  789.,  790.,  791.,  792.,
      793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,  797.,  798.,
      799.,  800.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      933.,  934.,  935.,  936.,  937.,  938.,  939.,  940.,  941.,  942.,
      943.,  944.,  945.,  946.,  947.,  948.,  949.,  950.,  951.,  952.,
      953.,  954.,  955.,  956.,  957.,  958.,  959.,  960.,  957.,  958.,
      959.,  960.,  957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,
      973.,  974.,  975.,  976.,  977.,  978.,  979.,  980.,  981.,  982.,
      983.,  984.,  985.,  986.,  987.,  988.,  989.,  990.,  991.,  992.,
      993.,  994.,  995.,  996.,  997.,  998.,  999.,  1000., 997.,  998.,
      999.,  1000., 997.,  998.,  999.,  1000., 997.,  998.,  999.,  1000.,
      1013., 1014., 1015., 1016., 1017., 1018., 1019., 1020., 1021., 1022.,
      1023., 1024., 1025., 1026., 1027., 1028., 1029., 1030., 1031., 1032.,
      1033., 1034., 1035., 1036., 1037., 1038., 1039., 1040., 1037., 1038.,
      1039., 1040., 1037., 1038., 1039., 1040., 1037., 1038., 1039., 1040.,
      1053., 1054., 1055., 1056., 1057., 1058., 1059., 1060., 1061., 1062.,
      1063., 1064., 1065., 1066., 1067., 1068., 1069., 1070., 1071., 1072.,
      1073., 1074., 1075., 1076., 1077., 1078., 1079., 1080., 1077., 1078.,
      1079., 1080., 1077., 1078., 1079., 1080., 1077., 1078., 1079., 1080.,
      1093., 1094., 1095., 1096., 1097., 1098., 1099., 1100., 1101., 1102.,
      1103., 1104., 1105., 1106., 1107., 1108., 1109., 1110., 1111., 1112.,
      1113., 1114., 1115., 1116., 1117., 1118., 1119., 1120., 1117., 1118.,
      1119., 1120., 1117., 1118., 1119., 1120., 1117., 1118., 1119., 1120.,
      1133., 1134., 1135., 1136., 1137., 1138., 1139., 1140., 1141., 1142.,
      1143., 1144., 1145., 1146., 1147., 1148., 1149., 1150., 1151., 1152.,
      1153., 1154., 1155., 1156., 1157., 1158., 1159., 1160., 1157., 1158.,
      1159., 1160., 1157., 1158., 1159., 1160., 1157., 1158., 1159., 1160.,
      1173., 1174., 1175., 1176., 1177., 1178., 1179., 1180., 1181., 1182.,
      1183., 1184., 1185., 1186., 1187., 1188., 1189., 1190., 1191., 1192.,
      1193., 1194., 1195., 1196., 1197., 1198., 1199., 1200., 1197., 1198.,
      1199., 1200., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.,
      1173., 1174., 1175., 1176., 1177., 1178., 1179., 1180., 1181., 1182.,
      1183., 1184., 1185., 1186., 1187., 1188., 1189., 1190., 1191., 1192.,
      1193., 1194., 1195., 1196., 1197., 1198., 1199., 1200., 1197., 1198.,
      1199., 1200., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.,
      1173., 1174., 1175., 1176., 1177., 1178., 1179., 1180., 1181., 1182.,
      1183., 1184., 1185., 1186., 1187., 1188., 1189., 1190., 1191., 1192.,
      1193., 1194., 1195., 1196., 1197., 1198., 1199., 1200., 1197., 1198.,
      1199., 1200., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.,
      1173., 1174., 1175., 1176., 1177., 1178., 1179., 1180., 1181., 1182.,
      1183., 1184., 1185., 1186., 1187., 1188., 1189., 1190., 1191., 1192.,
      1193., 1194., 1195., 1196., 1197., 1198., 1199., 1200., 1197., 1198.,
      1199., 1200., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride1Forward, VALID3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      265.,  266.,  267.,  268.,  269.,  270.,  271.,  272.,  273.,  274.,
      275.,  276.,  277.,  278.,  279.,  280.,  305.,  306.,  307.,  308.,
      309.,  310.,  311.,  312.,  313.,  314.,  315.,  316.,  317.,  318.,
      319.,  320.,  345.,  346.,  347.,  348.,  349.,  350.,  351.,  352.,
      353.,  354.,  355.,  356.,  357.,  358.,  359.,  360.,  385.,  386.,
      387.,  388.,  389.,  390.,  391.,  392.,  393.,  394.,  395.,  396.,
      397.,  398.,  399.,  400.,  665.,  666.,  667.,  668.,  669.,  670.,
      671.,  672.,  673.,  674.,  675.,  676.,  677.,  678.,  679.,  680.,
      705.,  706.,  707.,  708.,  709.,  710.,  711.,  712.,  713.,  714.,
      715.,  716.,  717.,  718.,  719.,  720.,  745.,  746.,  747.,  748.,
      749.,  750.,  751.,  752.,  753.,  754.,  755.,  756.,  757.,  758.,
      759.,  760.,  785.,  786.,  787.,  788.,  789.,  790.,  791.,  792.,
      793.,  794.,  795.,  796.,  797.,  798.,  799.,  800.,  1065., 1066.,
      1067., 1068., 1069., 1070., 1071., 1072., 1073., 1074., 1075., 1076.,
      1077., 1078., 1079., 1080., 1105., 1106., 1107., 1108., 1109., 1110.,
      1111., 1112., 1113., 1114., 1115., 1116., 1117., 1118., 1119., 1120.,
      1145., 1146., 1147., 1148., 1149., 1150., 1151., 1152., 1153., 1154.,
      1155., 1156., 1157., 1158., 1159., 1160., 1185., 1186., 1187., 1188.,
      1189., 1190., 1191., 1192., 1193., 1194., 1195., 1196., 1197., 1198.,
      1199., 1200.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
